home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / lockd / lockd.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  7KB  |  228 lines
  1. /*
  2.  * linux/include/linux/lockd/lockd.h
  3.  *
  4.  * General-purpose lockd include file.
  5.  *
  6.  * Copyright (C) 1996 Olaf Kirch <okir@monad.swb.de>
  7.  */
  8.  
  9. #ifndef LINUX_LOCKD_LOCKD_H
  10. #define LINUX_LOCKD_LOCKD_H
  11.  
  12. #ifdef __KERNEL__
  13.  
  14. #include <linux/config.h>
  15. #include <linux/in.h>
  16. #include <linux/fs.h>
  17. #include <linux/utsname.h>
  18. #include <linux/nfsd/nfsfh.h>
  19. #include <linux/lockd/bind.h>
  20. #include <linux/lockd/xdr.h>
  21. #ifdef CONFIG_LOCKD_V4
  22. #include <linux/lockd/xdr4.h>
  23. #endif
  24. #include <linux/lockd/debug.h>
  25.  
  26. /*
  27.  * Version string
  28.  */
  29. #define LOCKD_VERSION        "0.5"
  30.  
  31. /*
  32.  * Default timeout for RPC calls (seconds)
  33.  */
  34. #define LOCKD_DFLT_TIMEO    10
  35.  
  36. /*
  37.  * Lockd host handle (used both by the client and server personality).
  38.  */
  39. struct nlm_host {
  40.     struct nlm_host *    h_next;        /* linked list (hash table) */
  41.     struct sockaddr_in    h_addr;        /* peer address */
  42.     struct rpc_clnt    *    h_rpcclnt;    /* RPC client to talk to peer */
  43.     char            h_name[20];    /* remote hostname */
  44.     u32            h_version;    /* interface version */
  45.     rpc_authflavor_t    h_authflavor;    /* RPC authentication type */
  46.     unsigned short        h_proto;    /* transport proto */
  47.     unsigned short        h_reclaiming : 1,
  48.                 h_server     : 1, /* server side, not client side */
  49.                 h_inuse      : 1,
  50.                 h_killed     : 1,
  51.                 h_monitored  : 1;
  52.     wait_queue_head_t    h_gracewait;    /* wait while reclaiming */
  53.     u32            h_state;    /* pseudo-state counter */
  54.     u32            h_nsmstate;    /* true remote NSM state */
  55.     u32            h_pidcount;    /* Pseudopids */
  56.     atomic_t        h_count;    /* reference count */
  57.     struct semaphore    h_sema;        /* mutex for pmap binding */
  58.     unsigned long        h_nextrebind;    /* next portmap call */
  59.     unsigned long        h_expires;    /* eligible for GC */
  60.     struct list_head    h_lockowners;    /* Lockowners for the client */
  61.     spinlock_t        h_lock;
  62. };
  63.  
  64. /*
  65.  * Map an fl_owner_t into a unique 32-bit "pid"
  66.  */
  67. struct nlm_lockowner {
  68.     struct list_head list;
  69.     atomic_t count;
  70.  
  71.     struct nlm_host *host;
  72.     fl_owner_t owner;
  73.     uint32_t pid;
  74. };
  75.  
  76. /*
  77.  * Memory chunk for NLM client RPC request.
  78.  */
  79. #define NLMCLNT_OHSIZE        (sizeof(system_utsname.nodename)+10)
  80. struct nlm_rqst {
  81.     unsigned int        a_flags;    /* initial RPC task flags */
  82.     struct nlm_host *    a_host;        /* host handle */
  83.     struct nlm_args        a_args;        /* arguments */
  84.     struct nlm_res        a_res;        /* result */
  85.     char            a_owner[NLMCLNT_OHSIZE];
  86. };
  87.  
  88. /*
  89.  * This struct describes a file held open by lockd on behalf of
  90.  * an NFS client.
  91.  */
  92. struct nlm_file {
  93.     struct nlm_file *    f_next;        /* linked list */
  94.     struct nfs_fh        f_handle;    /* NFS file handle */
  95.     struct file *        f_file;        /* VFS file pointer */
  96.     struct nlm_share *    f_shares;    /* DOS shares */
  97.     struct nlm_block *    f_blocks;    /* blocked locks */
  98.     unsigned int        f_locks;    /* guesstimate # of locks */
  99.     unsigned int        f_count;    /* reference count */
  100.     struct semaphore    f_sema;        /* avoid concurrent access */
  101.     int                   f_hash;        /* hash of f_handle */
  102. };
  103.  
  104. /*
  105.  * This is a server block (i.e. a lock requested by some client which
  106.  * couldn't be granted because of a conflicting lock).
  107.  */
  108. #define NLM_NEVER        (~(unsigned long) 0)
  109. struct nlm_block {
  110.     struct nlm_block *    b_next;        /* linked list (all blocks) */
  111.     struct nlm_block *    b_fnext;    /* linked list (per file) */
  112.     struct nlm_rqst        b_call;        /* RPC args & callback info */
  113.     struct svc_serv *    b_daemon;    /* NLM service */
  114.     struct nlm_host *    b_host;        /* host handle for RPC clnt */
  115.     unsigned long        b_when;        /* next re-xmit */
  116.     unsigned int        b_id;        /* block id */
  117.     unsigned char        b_queued;    /* re-queued */
  118.     unsigned char        b_granted;    /* VFS granted lock */
  119.     unsigned char        b_incall;    /* doing callback */
  120.     unsigned char        b_done;        /* callback complete */
  121.     struct nlm_file *    b_file;        /* file in question */
  122. };
  123.  
  124. /*
  125.  * Valid actions for nlmsvc_traverse_files
  126.  */
  127. #define NLM_ACT_CHECK        0        /* check for locks */
  128. #define NLM_ACT_MARK        1        /* mark & sweep */
  129. #define NLM_ACT_UNLOCK        2        /* release all locks */
  130.  
  131. /*
  132.  * Global variables
  133.  */
  134. extern struct rpc_program    nlm_program;
  135. extern struct svc_procedure    nlmsvc_procedures[];
  136. #ifdef CONFIG_LOCKD_V4
  137. extern struct svc_procedure    nlmsvc_procedures4[];
  138. #endif
  139. extern int            nlmsvc_grace_period;
  140. extern unsigned long        nlmsvc_timeout;
  141.  
  142. /*
  143.  * Lockd client functions
  144.  */
  145. struct nlm_rqst * nlmclnt_alloc_call(void);
  146. int          nlmclnt_call(struct nlm_rqst *, u32);
  147. int          nlmclnt_async_call(struct nlm_rqst *, u32, rpc_action);
  148. int          nlmclnt_block(struct nlm_host *, struct file_lock *, u32 *);
  149. int          nlmclnt_cancel(struct nlm_host *, struct file_lock *);
  150. u32          nlmclnt_grant(struct nlm_lock *);
  151. void          nlmclnt_recovery(struct nlm_host *, u32);
  152. int          nlmclnt_reclaim(struct nlm_host *, struct file_lock *);
  153. int          nlmclnt_setgrantargs(struct nlm_rqst *, struct nlm_lock *);
  154. void          nlmclnt_freegrantargs(struct nlm_rqst *);
  155.  
  156. /*
  157.  * Host cache
  158.  */
  159. struct nlm_host * nlmclnt_lookup_host(struct sockaddr_in *, int, int);
  160. struct nlm_host * nlmsvc_lookup_host(struct svc_rqst *);
  161. struct nlm_host * nlm_lookup_host(int server, struct sockaddr_in *, int, int);
  162. struct rpc_clnt * nlm_bind_host(struct nlm_host *);
  163. void          nlm_rebind_host(struct nlm_host *);
  164. struct nlm_host * nlm_get_host(struct nlm_host *);
  165. void          nlm_release_host(struct nlm_host *);
  166. void          nlm_shutdown_hosts(void);
  167. extern struct nlm_host *nlm_find_client(void);
  168.  
  169.  
  170. /*
  171.  * Server-side lock handling
  172.  */
  173. int          nlmsvc_async_call(struct nlm_rqst *, u32, rpc_action);
  174. u32          nlmsvc_lock(struct svc_rqst *, struct nlm_file *,
  175.                     struct nlm_lock *, int, struct nlm_cookie *);
  176. u32          nlmsvc_unlock(struct nlm_file *, struct nlm_lock *);
  177. u32          nlmsvc_testlock(struct nlm_file *, struct nlm_lock *,
  178.                     struct nlm_lock *);
  179. u32          nlmsvc_cancel_blocked(struct nlm_file *, struct nlm_lock *);
  180. unsigned long      nlmsvc_retry_blocked(void);
  181. int          nlmsvc_traverse_blocks(struct nlm_host *, struct nlm_file *,
  182.                     int action);
  183. void      nlmsvc_grant_reply(struct svc_rqst *, struct nlm_cookie *, u32);
  184.  
  185. /*
  186.  * File handling for the server personality
  187.  */
  188. u32          nlm_lookup_file(struct svc_rqst *, struct nlm_file **,
  189.                     struct nfs_fh *);
  190. void          nlm_release_file(struct nlm_file *);
  191. void          nlmsvc_mark_resources(void);
  192. void          nlmsvc_free_host_resources(struct nlm_host *);
  193. void          nlmsvc_invalidate_all(void);
  194.  
  195. static __inline__ struct inode *
  196. nlmsvc_file_inode(struct nlm_file *file)
  197. {
  198.     return file->f_file->f_dentry->d_inode;
  199. }
  200.  
  201. /*
  202.  * Compare two host addresses (needs modifying for ipv6)
  203.  */
  204. static __inline__ int
  205. nlm_cmp_addr(struct sockaddr_in *sin1, struct sockaddr_in *sin2)
  206. {
  207.     return sin1->sin_addr.s_addr == sin2->sin_addr.s_addr;
  208. }
  209.  
  210. /*
  211.  * Compare two NLM locks.
  212.  * When the second lock is of type F_UNLCK, this acts like a wildcard.
  213.  */
  214. static __inline__ int
  215. nlm_compare_locks(struct file_lock *fl1, struct file_lock *fl2)
  216. {
  217.     return    fl1->fl_pid   == fl2->fl_pid
  218.          && fl1->fl_start == fl2->fl_start
  219.          && fl1->fl_end   == fl2->fl_end
  220.          &&(fl1->fl_type  == fl2->fl_type || fl2->fl_type == F_UNLCK);
  221. }
  222.  
  223. extern struct lock_manager_operations nlmsvc_lock_operations;
  224.  
  225. #endif /* __KERNEL__ */
  226.  
  227. #endif /* LINUX_LOCKD_LOCKD_H */
  228.